package utils

import (
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"regexp"
	"strconv"
	"strings"
	"unicode/utf8"
)

// 保存日志
func SaveLog(info string) {
	// 获取当前工作目录
	currentDir, errs := os.Getwd()
	if errs != nil {
		log.Fatal(errs)
	}
	filePath := currentDir + "/log.txt"

	// 检查文件是否存在
	_, err := os.Stat(filePath)
	if os.IsNotExist(err) {
		// 文件不存在，创建并写入内容
		err = ioutil.WriteFile(filePath, []byte(info), 0644)
		if err != nil {
			fmt.Println("创建文件失败：", err)
			return
		}
		// fmt.Println("文件已成功创建并写入")
	} else {
		// 文件存在，追加内容
		// 打开文件
		file, err := os.OpenFile(filePath, os.O_APPEND|os.O_WRONLY, 0644)
		if err != nil {
			log.Fatal(err)
		}
		defer file.Close()

		// 将内容追加到文件末尾
		_, err = file.Write([]byte(info))
		if err != nil {
			log.Fatal(err)
		}
	}
}

// 解析中文字符
func ParsingChineseChar(str string) string {
	// 替换每个\\uXXXX为对应的字符
	decoded := ""
	start := 0
	for start < len(str) {
		if str[start:start+6] == "\\\\u" {
			// 提取4位十六进制数
			end := start + 6
			for end < len(str) && str[end] != '\\' {
				end++
			}
			if end-start == 6 { // 确保我们有一个完整的\\uXXXX序列
				code, err := strconv.ParseUint(str[start+2:end], 16, 32)
				if err == nil {
					r := rune(code)
					decoded += string(r)
					start = end
					continue
				}
			}
		}
		decoded += string(str[start])
		start++
	}

	fmt.Println(decoded) // 输出解析后的字符串
	return decoded
}

// 删除字符串最后一位
func RemoveLastSubstring(s, substr string) string {
	lastIndex := strings.LastIndex(s, substr)
	if lastIndex == -1 {
		return s // 子串未找到，返回原字符串
	}
	return s[:lastIndex] + s[lastIndex+len(substr):]
}

func IsUtf8(str []byte) {
	// 验证是否为有效的UTF-8
	if !utf8.Valid(str) {
		fmt.Println("The string is not valid UTF-8")
	} else {
		fmt.Println("The string is valid UTF-8")
	}
}

// 解析Unicode中文编码
func ParseUnicode(s string) (string, error) {
	// 使用正则表达式匹配\\uXXXX序列
	re := regexp.MustCompile(`\\u([0-9a-fA-F]{4})`)
	matches := re.FindAllStringSubmatch(s, -1)

	for _, match := range matches {
		// 将16进制字符串转换为rune
		code, err := strconv.ParseUint(match[1], 16, 16)
		if err != nil {
			return "", err
		}
		// 将rune替换回原始字符串中的\\uXXXX序列
		s = strings.Replace(s, "\\u"+match[1], string(rune(code)), -1)
	}

	return s, nil
}

/*
 *InsertString 在原始字符串src的index位置插入字符串insertStr
 *如果index超出src的长度，则append到src的末尾
 */
func InsertString(src string, insertStr string, index int) string {
	if index < 0 {
		index = 0 // 如果index小于0，则从字符串开头插入
	}
	if index > len(src) {
		return src + insertStr // 如果index大于src的长度，则直接追加到末尾
	}
	return src[:index] + insertStr + src[index:]
}

// 输出间隔符
func PrintSeparator() {
	fmt.Println("<-------------------------------------------------->")
}

// 打印输出结构体信息
func PrintStruct(item interface{}) {
	fmt.Printf("%#v\n", item)
}
